
/**
 * 文件读取存储工具类
 */
const fs = uni.getFileSystemManager();
export const BasePath = wx.env.USER_DATA_PATH;
const fileUtil = {
	
	/**
	 * 异步判断文件/目录是否存在
	 * @param {string} path 要判断是否存在的文件/目录路径 (本地路径)
	 * @return {Promise<boolean>} 是否存在
	 */
	hasFileOrDir(path: string): Promise<boolean> {
		return new Promise((resolve, reject) => {
			fs.access({
			  path: `${BasePath}${path}`,
			  success(res) {
			    // 文件存在
			    resolve(true);
			  },
			  fail(err) {
			    // 文件不存在或其他错误
				console.error(`find '${path}' error: `, err);
			    resolve(false);
			  }
			})
		})
	},
	
	/**
	 * 同步判断文件/目录是否存在
	 * @param {string} path 要判断是否存在的文件/目录路径 (本地路径)
	 * @return {boolean} 是否存在
	 */
	hasFileOrDirSync(path: string): boolean {
		try {
			fs.accessSync(`${BasePath}${path}`);
			return true;
		} catch(err) {
			console.error(`find '${path}' error: `, err);
			return false;
		}
	},
	
	/**
	 * 异步创建目录
	 * @param {string} dirPath 创建的目录路径 (本地路径)
	 * @param {boolean} [recursive=false] 是否在递归创建该目录的上级目录后再创建该目录。如果对应的上级目录已经存在，则不创建该上级目录
	 * @return {Promise<boolean>} 是否创建成功
	 */
	mkdir(dirPath: string, recursive: boolean = false): Promise<boolean> {
		return new Promise((resolve, reject) => {
			fs.mkdir({
				dirPath: `${BasePath}${dirPath}`,
				recursive,
				success(res) {
					resolve(true);
				},
				fail(err) {
					console.error(`mkdir '${dirPath}' failed: `, err);
					resolve(false);
				}
			})
		})
	},
	
	/**
	 * 同步创建目录
	 * @param {string} dirPath 创建的目录路径 (本地路径)
	 * @param {boolean} [recursive=false] 是否在递归创建该目录的上级目录后再创建该目录。如果对应的上级目录已经存在，则不创建该上级目录
	 * @return {boolean} 是否创建成功
	 */
	mkdirSync(dirPath: string, recursive: boolean = false): boolean {
		try {
			fs.mkdirSync(`${BasePath}${dirPath}`, recursive);
			return true;
		} catch(err) {
			console.error(`mkdir '${dirPath}' failed: `, err);
			return false;
		}
	},
	
	
	/**
	 * 异步读取目录内文件列表
	 * @param {string} dirPath 要读取的目录路径 (本地路径)
	 * @return {Promise<string[]>} 指定目录下的文件名数组
	 */
	readdir(dirPath: string): Promise<string[]> {
		return new Promise((resolve, reject) => {
			fs.readdir({
				dirPath: `${BasePath}${dirPath}`,
				success(res) {
					resolve(res.files);
				},
				fail(err) {
					console.error(`readdir '${dirPath}' failed: `, err);
					resolve([]);
				}
			})
		})
	},
	
	/**
	 * 同步读取目录内文件列表
	 * @param {string} dirPath 要读取的目录路径 (本地路径)
	 * @return {string[]} 指定目录下的文件名数组
	 */
	readdirSync(dirPath: string): string[] {
		try {
			return fs.readdirSync(`${BasePath}${dirPath}`);
		} catch(err) {
			// console.error(`readdir '${dirPath}' failed: `, err);
			return [];
		}
	},
	
	/**
	 * 异步重命名文件。可以把文件从 oldPath 移动到 newPath
	 * @param {string} oldPath 源文件路径，支持本地路径
	 * @param {string} newPath 新文件路径，支持本地路径
	 * @return {Promise<boolean>} 是否重命名成功 
	 */
	rename(oldPath: string, newPath: string): Promise<boolean> {
		return new Promise((resolve, reject) => {
			fs.rename({
				oldPath: `${BasePath}${oldPath}`,
				newPath: `${BasePath}${newPath}`,
				success(res) {
					resolve(true);
				},
				fail(err) {
					console.error(`rename from '${oldPath}' to '${newPath}' error: `, err);
					resolve(false);
				}
			})
		})
	},
	
	/**
	 * 同步重命名文件。可以把文件从 oldPath 移动到 newPath
	 * @param {string} oldPath 源文件路径，支持本地路径
	 * @param {string} newPath 新文件路径，支持本地路径
	 * @return {boolean} 是否重命名成功 
	 */
	renameSync(oldPath: string, newPath: string): boolean {
		try {
			fs.renameSync(`${BasePath}${oldPath}`, `${BasePath}${newPath}`);
			return true;
		} catch(err) {
			console.error(`rename from '${oldPath}' to '${newPath}' error: `, err);
			return false;
		}
	},
	
	/**
	 * 异步删除目录
	 * @param {string} dirPath 要删除的目录路径 (本地路径)
	 * @param {boolean} [recursive=false] 是否递归删除目录。如果为 true，则删除该目录和该目录下的所有子目录以及文件。
	 * @return {Promise<boolean>} 是否删除目录成功
	 */
	rmdir(dirPath: string, recursive: boolean = false): Promise<boolean> {
		return new Promise((resolve, reject) => {
			fs.rmdir({
				dirPath: `${BasePath}${dirPath}`,
				recursive,
				success(res) {
					resolve(true);
				},
				fail(err) {
					console.error(`rmdir '${dirPath}' error: `, err);
					resolve(false);
				}
			})
		})
	},
	
	/**
	 * 同步删除目录
	 * @param {string} dirPath 要删除的目录路径 (本地路径)
	 * @param {boolean} [recursive=false] 是否递归删除目录。如果为 true，则删除该目录和该目录下的所有子目录以及文件。
	 * @return {boolean} 是否删除目录成功
	 */
	rmdirSync(dirPath: string, recursive: boolean = false): boolean {
		try {
			fs.rmdirSync(`${BasePath}${dirPath}`, recursive);
			return true;
		} catch(err) {
			console.error(`rmdir '${dirPath}' error: `, err);
			return false;
		}
	},
	
	/**
	 * 异步保存临时文件到本地。此接口会移动临时文件，因此调用成功后，tempFilePath 将不可用
	 * @param {string} tempFilePath 临时存储文件路径 (本地路径)
	 * @param {string} filePath 要存储的文件路径 (本地路径)
	 * @return {Promise<string>} 存储后的文件路径 (本地路径)
	 */
	saveFile(tempFilePath: string, filePath?: string): Promise<string> {
		return new Promise((resolve, reject) => {
			fs.saveFile({
				tempFilePath,
				filePath: filePath && `${BasePath}${filePath}`,
				success(res) {
					resolve(res.savedFilePath);
				},
				fail(err) {
					console.error(`save file '${tempFilePath}' to '${filePath}' failed: `, err);
					resolve("");
				}
			})
		})
	},
	
	
	/**
	 * 同步保存临时文件到本地。此接口会移动临时文件，因此调用成功后，tempFilePath 将不可用
	 * @param {string} tempFilePath 临时存储文件路径 (本地路径)
	 * @param {string} filePath 要存储的文件路径 (本地路径)
	 * @return {string} 存储后的文件路径 (本地路径)
	 */
	saveFileSync(tempFilePath: string, filePath?: string): string {
		try {
			return fs.saveFileSync(tempFilePath, filePath && `${BasePath}${filePath}`);
		} catch(err) {
			console.error(`save file '${tempFilePath}' to '${filePath}' failed: `, err);
			return "";
		}
	},
	
	/**
	 * 异步复制文件
	 * @param {string} srcPath 源文件路径，支持本地路径
	 * @param {string} destPath 目标文件路径，支持本地路径
	 * @return {Promise<boolean>} 是否复制成功
	 */
	copyFile(srcPath: string, destPath: string): Promise<boolean> {
		return new Promise((resolve, reject) => {
			fs.copyFile({
				srcPath,
				destPath: `${BasePath}${destPath}`,
				success(res) {
					return true;
				},
				fail(err) {
					console.error(`copy '${srcPath}' to '${destPath}' failed: `, err)
					return false;
				}
			})
		})
	},
	
	/**
	 * 同步复制文件
	 * @param {string} srcPath 源文件路径，支持本地路径
	 * @param {string} destPath 目标文件路径，支持本地路径
	 * @return {boolean} 是否复制成功
	 */
	copyFileSync(srcPath: string, destPath: string): boolean {
		try {
			fs.copyFileSync(srcPath, `${BasePath}${destPath}`);
			return true;
		} catch(err) {
			console.error(`copy '${srcPath}' to '${destPath}' failed: `, err)
			return false;
		}
	},
	
	/**
	 * 删除文件
	 * @param {string} filePath 要删除的文件路径 (本地路径)
	 * @return {Promise<boolean>} 是否删除成功
	 */
	deleteFile(filePath: string): Promise<boolean> {
		return new Promise((resolve, reject) => {
			fs.unlink({
				filePath: `${BasePath}${filePath}`,
				success(res) {
					resolve(true);
				},
				fail(err) {
					console.error(`delete file '${filePath}' failed: `, err);
					resolve(false);
				}
			})
		})
	},
	
	
	/**
	 * 删除文件
	 * @param {string} filePath 要删除的文件路径 (本地路径)
	 * @return {boolean} 是否删除成功
	 */
	deleteFileSync(filePath: string): boolean {
		try {
			fs.unlinkSync(`${BasePath}${filePath}`);
			return true;
		} catch(err) {
			console.error(`delete file '${filePath}' failed: `, err);
			return false;
		}
	},
	
	/**
	 * 异步获取该小程序下已保存的本地缓存文件列表
	 * @return {Promise<UniApp.FileItem>} 本地缓存文件列表
	 */
	getSavedFileList(): Promise<Array<UniApp.FileItem>> {
		return new Promise((resolve, reject) => {
			fs.getSavedFileList({
				success(res) {
					console.log("fs.getSavedFileList: ", res)
					resolve(res.fileList);
				},
				fail(err) {
					resolve([]);
				}
			})
		})
	},
	
	
}

export const getFileSuffix = (fileName: string) => {
	return fileName.substring(fileName.lastIndexOf("."));
}

/**
 * 校验文件名是否合法（最佳实践版）
 * @param filename 要校验的文件名
 * @returns 返回校验结果 { isValid: boolean, message?: string }
 */
export const validateFilename = (filename: string): { isValid: boolean; message: string } => {
	// 1. 基础检查
	if (!filename || filename.trim().length === 0) {
		return { isValid: false, message: '文件名不能为空' };
	}

	// 2. 长度检查（建议不超过20字符）
	if (filename.length > 20) {
		return { isValid: false, message: '文件名过长（最多20个字符）' };
	}

	// 3. 禁止字符检查
	const illegalChars = /[\\/:*?"<>|\0]/;
	if (illegalChars.test(filename)) {
		return {
			isValid: false,
			message: '文件名不能包含以下字符: \\ / : * ? " < > |'
		};
	}

	// 4. 开头/结尾检查
	if (/^[. ]|[. ]$/.test(filename)) {
		return { isValid: false, message: '文件名不能以空格或点开头/结尾' };
	}


	// 5. 连续点检查
	if (filename.includes('..')) {
		return { isValid: false, message: '文件名不能包含连续的点' };
	}

	return { isValid: true, message: "" };
}

export default fileUtil;